// Copyright (c) 2024, BlockProject 3D

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without modification,

// are permitted provided that the following conditions are met:

//

//     * Redistributions of source code must retain the above copyright notice,

//       this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above copyright notice,

//       this list of conditions and the following disclaimer in the documentation

//       and/or other materials provided with the distribution.

//     * Neither the name of BlockProject 3D nor the names of its contributors

//       may be used to endorse or promote products derived from this software

//       without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

use crate::api::core::Error;

use crate::compiler;

use crate::compiler::util::imports::{ImportSolver, ProtocolStore};

use crate::gen::codec::CodecMap;

use crate::gen::file::FileType;

use bp3d_debug::trace;

use bp3d_util::index_map::IndexMap;

use bp3d_util::path::PathExt;

use std::marker::PhantomData;

use std::path::{Path, PathBuf};

pub struct Context<'a, I: ImportSolver> {

    items: IndexMap<Item<'a>>,

    pub protocols: &'a ProtocolStore<'a, I>,

}

impl<'a, I: ImportSolver> Context<'a, I> {

    pub fn new(protocols: &'a ProtocolStore<'a, I>) -> Self {

        Self {

            items: IndexMap::with_capacity(protocols.len()),

            protocols,

        }

    }

    pub fn generate<G: crate::gen::Generator>(

        &mut self,

        generator: &Generator<G>,

        full_name: impl AsRef<str>,

        params: &Params,

        generator_params: &G::Params<'_>,

    ) -> Result<(), Error> {

        if self.get(full_name.as_ref()).is_none() {

  Branch (60:12): [True: 10, False: 0]

  Branch (60:12): [True: 0, False: 0]

  Branch (60:12): [Folded - Ignored]

            let protocol = self

                .protocols

                .get(full_name.as_ref())

                .ok_or_else(|| 
Error::ProtocolNotFound(full_name.as_ref().into())0
)
?0
;

            self.items.insert(generator.generate(protocol, params, generator_params)
?0
);

        }

        Ok(())

    }

    pub fn generate_all<G: crate::gen::Generator>(

        &mut self,

        generator: &Generator<G>,

        params: &Params,

        generator_params: &G::Params<'_>,

    ) -> Result<(), Error> {

        for protocol in 
self.protocols.iter()2
 {

            if self.get(&protocol.full_name).is_none() {

  Branch (77:16): [True: 25, False: 10]

  Branch (77:16): [True: 0, False: 0]

  Branch (77:16): [Folded - Ignored]

                self.items.insert(generator.generate(protocol, params, generator_params)
?0
);

            }

        }

        Ok(())

    }

    pub fn get(&self, full_name: &str) -> Option<&Item<'a>> {

        self.items.get(full_name)

    }

    pub fn iter(&self) -> impl Iterator<Item = &Item<'a>> {

        self.items.iter()

    }

}

pub struct Item<'a> {

    full_name: &'a str,

    pub name: &'a str,

    pub path: PathBuf,

}

impl bp3d_util::index_map::Index for Item<'_> {

    type Key = str;

    fn index(&self) -> &Self::Key {

        self.full_name

    }

}

#[derive(Copy, Clone, Debug)]

pub struct Params {

    pub write_messages: bool,

    pub read_messages: bool,

    pub use_enums: bool,

    pub use_structs: bool,

    pub use_messages: bool,

    pub use_unions: bool,

}

impl Default for Params {

    fn default() -> Self {

        Self {

            write_messages: true,

            read_messages: true,

            use_enums: true,

            use_structs: true,

            use_messages: true,

            use_unions: true,

        }

    }

}

impl Params {

    pub fn new() -> Self {

        Self {

            write_messages: false,

            read_messages: false,

            use_enums: false,

            use_structs: false,

            use_messages: false,

            use_unions: false,

        }

    }

}

pub struct Generator<'a, G> {

    generator: PhantomData<G>,

    out_directory: &'a Path,

    file_header: Option<&'a Path>,

    codec_map: CodecMap<'a, 'a>,

}

impl<'a, G: crate::gen::Generator> Generator<'a, G> {

    pub fn new(out_directory: &'a Path, codecs: CodecMap<'a, 'a>, _: G) -> Self {

        Self {

            out_directory,

            generator: PhantomData,

            file_header: None,

            codec_map: codecs,

        }

    }

    pub fn with_default_codecs(out_directory: &'a Path, _: G) -> Self {

        Self {

            out_directory,

            generator: PhantomData,

            file_header: None,

            codec_map: G::get_default_codecs()

        }

    }

    pub fn set_file_header(&mut self, path: &'a Path) -> &mut Self {

        self.file_header = Some(path);

        self

    }

    pub fn generate<'b>(

        &self,

        protocol: &'b compiler::Protocol,

        params: &Params,

        generator_params: &G::Params<'_>,

    ) -> Result<Item<'b>, Error> {

        trace!({?params}, "Generating protocol {}", protocol.full_name);

        let file_header = self

            .file_header

            .map(std::fs::read_to_string)

            .transpose()

            .map_err(Error::Io)
?0

            .map(|v| 
G::generate_file_header(v.lines())0
);

        let name = protocol.name();

        let files =

            G::generate(protocol, &self.codec_map, generator_params).map_err(|e| 
Error::Generator(e.to_string())0
)
?0
;

        let out_path = self.out_directory.join(name);

        if !out_path.exists() {

  Branch (191:12): [True: 35, False: 0]

  Branch (191:12): [True: 0, False: 0]

  Branch (191:12): [Folded - Ignored]

            std::fs::create_dir(&out_path).map_err(Error::Io)
?0
;

        }

        let 
files_iter = files.into_iter().filter(35
|v| {

            let value = match v.ty() {

                FileType::MessageWriting => params.write_messages,

                FileType::MessageReading => params.read_messages,

                FileType::Message => params.use_messages,

                FileType::Structure => params.use_structs,

                FileType::Enum => params.use_enums,

                FileType::Union => params.use_unions,

            };

            if !value {

  Branch (203:16): [True: 2, False: 209]
  Branch (203:16): [True: 0, False: 0]

  Branch (203:16): [Folded - Ignored]

                trace!("Excluding {:?} from generation", v);

            } else {

                trace!("Including {:?} in generation", v);

            }

            value

        }
)35
;

        let iter = files_iter

            .into_iter()

            .map(|v| v.write(&out_path, file_header.as_deref(), G::get_language_extension()))

            .filter_map(|v| match v {

                Ok(o) => o.map(Ok),

                Err(e) => Some(Err(e)),

            })

            .collect::<std::io::Result<Vec<PathBuf>>>()

            .map_err(Error::Io)
?0
;

        let 
umbrella35
 = 
G::generate_umbrella(name, iter.iter().map(35
|v| &**v), generator_params)

            .map_err(|e| 
Error::Generator(e.to_string())0
)
?0
;

        let proto_path = if umbrella.len() > 1 {

  Branch (221:29): [True: 35, False: 0]

  Branch (221:29): [True: 0, False: 0]

  Branch (221:29): [Folded - Ignored]

            let umbrella_path = out_path.join("umbrella").ensure_extension(G::get_language_extension()).to_path_buf();

            std::fs::write(&umbrella_path, umbrella).map_err(Error::Io)
?0
;

            umbrella_path

        } else {

            out_path

        };

        Ok(Item {

            full_name: &protocol.full_name,

            name,

            path: proto_path,

        })

    }

}